#特殊标识符  前后下划线是系统风格
#计算两个变量的和，参数可以是整数，也可以是浮点数，可以是字符串，主要支持+号操作符即可
# import test
# print(test.add._doc_)

#文档字符串 “”“ xxx ”“”     help()内建函数

#对象与类型 py中任何类型的值都是一个对象（判定是不是对象，就尝试去一下id看能否取到）包含类型 值 身份
# print(id(test))

# a = 2
# b = 3
# print(id(a), id(b))
# b = 2
# print(id(b))  #标签转移
#py是浅拷贝  a = 100， b = a都是100的引用，内存中只存了一份

#py是一种  动态强类型  的语言 ：越不支持隐式类型转换，类型越强
# 动态类型：一个变量在运行过程中类型发生变化
#静态类型：一个变量在运行过程中类型不能发生变化
# C是静态

#标准类型：整型，浮点型，复数型，布尔型，字符串，列表，元组，字典
#其他内建类型：类型，NULL对象，文件，函数，模块，类
# s = 'hehe'
# print(type(s))
# s =  None
# print(type(s))


#内建类型的布尔值
#所有的标准对象，均可以用于布尔测试（放入if条件中）
# ret = 21  #只要ret中有东西，就是True
# if ret:
#     print('hehe')
# else:
#     print('haha')

#对象的比较  （身份，类型，值）
# a = 10
# b = 10
# print(id(a) == id(b))
# print(a is b)  #iskeyibijiao  对应有is not
# print(type(a) == type(b))

#divmod（）  ：返回一个元组，同时计算商和余数
# num = 10
# num = str(num)
# print(type(num))

#round函数：对浮点数进行四舍五入，有两个参数，第一个是要进行计算的值，第二个是要保留小数后多少位
# import math
# print(round(math.pi, 3))

#math/cmath模块：cmath是复数运算模块

# import random
# print(random.randint(1,9))  #前后闭区间  产生随机数

#esle不光可以和if搭配  还可以和while  for搭配

#函数内部还可定义函数
#函数的参数：整数，字符串，列表

# def add(x = 0, y = 0):
#     return x + y
# print(add("hello", "world"))
# print(add([1,2,3], [4,5,6]))

# print(10,20,30,sep='$', end=';')

# a = [231,2,4,4,5]
# print(sorted(a))  #sorted  排序内建函数，元组，   但是返回都是列表
# print(sorted(a,reverse=True))   #逆序

# def log(*msg):
#     #msg变成了一个列表
#     #两个星号变成字典
#     for m in msg:
#         print(m, end=',')
# log(10,20,30,3039)

# def point():
#     x = 10
#     y = 20
#     return x, y
# a, b = point()
# print(a, b)
#没return 那么返回的是None对象

#序列里面的元素顺序是很重要的
# a = [1,2,3]
# b = [3,2,1]
# c = ['hehe', 2,1]
# print(a < b)
# #print(a < c)
#
# print(2 in a)  #判断2是否在a中  not in
# print(a + b)
# print(a + c)
# d = (1,2,3)
# print(d * 5)

#序列的切片操作  [:]   [0:3]  [0:]  [:3]  [3]
#扩展切片操作 [：：]  最后多一个步长 [1:5:2]  表示从1开始到5 ，步长为2

#字符串翻转
# a = 'asdasdasd'
# print(a[::-1])

#len 求长度，，max求最大值，min最小
# a = [1,2,3,4,5]
# print(sum(a))
#内建函数enumerate
# def find(input_list,x)
#     for i value in enumerate(input_list):
#         if value == x:
#             return i
#         else
#             return None
import numpy
#zip  这个函数本意是拉链
# x = [1,2,3]
# y = [4,5,6]
# z = [2,3,4]
# print(list(zip(x, y, z)))
# for i in zip(x,y,z):
#     print(list(i))

#三种引号的区别  ‘’  与“”没区别
# a = 'abcder'
# #错误写法  z = a[0]
# a = 'z' + a[1:]
# print(a)

#只有列表和字典是可变对象  其他都是不可对象
#字符串的切片，比较，in/not in的规则与序列一样
#py的格式化操作

#startswith()  endwith()
# a = 'hello wordl'
# print(a.startswith('hello'))

#列表
# a = [1,2,3,4]
# a[0] = 100;
# print(a)
# a.append(2)
# print(a)
# a.insert(1,200)
# print(a)
# b = [5,6,7]
# print(a+b)
# # a.append(b)  #列表的元素可以是列表
# # print(a)
# a.extend(b)  #扩展
# print(a)
#
# a =[1,2,3,4]
# # del(a[3])  #按照下标删
# # print(a)
# # a.remove(2)  #按照值删
# a.pop(-1)  #删除最后一个
# print(a)
#
# a = [1,2,3,4]
# # print(a[::-1])  #没修改a
# # a.reverse()  #更改了a
# # print(a)
#
# a.sort()
# print(a)

# a =[1,2,3,4,5]
# b = a  #浅拷贝
# a[0] = 100
# print(b)

# import copy
# a = [10,20,30,40]
# b = copy.deepcopy(a)  #深拷贝  且只能针对可变对象使用   改一个  另一个不变
# a[0] = 100
# print(b)

#元组和列表绝大部操作类似  只不过元组是只读 不可修改
#所以reverse，sort，deepcopy元组都不支持
# def get_point():
#     return 10,20
# (x,y )= get_point()
# print(x,y)

#元组的两种重要场景
#1，函数传参时使用元组可以避免函数内部把函数外部的内容修改
#2，元组是可哈希的，元组可作为字典的key，而列表不行
# a = (1,2,3)
# b = {
#     a:100
# }
# print(b)  #若a换成列表则不可哈希

#若元组的元素是列表  就相当于像二维数组，这时可以改的！！1
# a = ([1,2,3], [4,5,6])
# a[0][0] = 100
# print(a)

##字典的key必须是可哈希，不可变是可哈希的一种  元素是键值对结构
# a = {
#     10:20,
#     'key':'value',
#     'a':100
# }
# #print(a[10])
# # for key in a:
# #     print(key,a[key])
# #
# # a[10] = '1000'
# # print(a[10])
# # a['id'] = 'hehe'  #键值对的插入操作   直接在字典元素末尾在加了一对键值对
# # print(a)
# # del(a[10])  #删除了第一对
# # print(a)
#
# print(a.keys())  #打印字典的所有key
# print(a.values())#返回所有的值
# print(a.items())#返回所有的


#集合
#a = set([1,7,3,4,5,2,2,2,])
# b = set([3,2,1])
# print(a == b)  #所以顺序没关系
# print(a, b)
# print(a & b)#求交集
# print(a | b)#  bingji
# print(a - b)
# print(a ^ b)

#集合还可以自动去重,自动排序
#int(a)

#导入模块
# import os,sys
# import os.path
# print(os.path.exists("d:sa"))
# import os.path as op  #起别名  等价于 op = os.path
#
# print(type(os.path))
#
# #导入模块中某一部分
# from os.path import exists
# print(exists("d\ddd"))
# from os.path import *  #导入os.path的所有


#导入模块  意味着被执行该模块

#locals（）  查看当前作用域下有哪些局部变量
#globals（）  查看当前作用狱下所有的全局变量
#_name_当前模块的名字
#如果这个py文件是入口文件，_name_的值就是_main_
#如果这个py文件不是入口文件，_name_的值就是当前文件不算后缀部分
# import test
# print(test._name_)


